package com.sxyjhh.utils;

import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;

import java.io.*;
import java.math.BigDecimal;

/**
 * 支持断点续传的FTP实用类
 *
 * @version 0.3 实现中文目录创建及中文文件创建，添加对于中文的支持
 *          Created by lwl on 2016/4/21.
 */
public class FtpUtil {
    public static FtpUtil ftputil;

    private FtpUtil() {
    }

    /**
     * 获得类的实例
     */
    public static synchronized FtpUtil getInstance() {
        if (ftputil == null) {
            ftputil = new FtpUtil();
        }
        return ftputil;
    }

    //枚举类UploadStatus代码
    public enum UploadStatus {
        Create_Directory_Fail,   //远程服务器相应目录创建失败
        Create_Directory_Success, //远程服务器闯将目录成功
        Upload_New_File_Success, //上传新文件成功
        Upload_New_File_Failed,   //上传新文件失败
        File_Exits,      //文件已经存在
        Remote_Bigger_Local,   //远程文件大于本地文件
        Upload_From_Break_Success, //断点续传成功
        Upload_From_Break_Failed, //断点续传失败
        Delete_Remote_Faild;   //删除远程文件失败
    }

    //枚举类DownloadStatus代码
    public enum DownloadStatus {
        Remote_File_Noexist, //远程文件不存在
        Local_Bigger_Remote, //本地文件大于远程文件
        Download_From_Break_Success, //断点下载文件成功
        Download_From_Break_Failed,   //断点下载文件失败
        Download_New_Success,    //全新下载文件成功
        Download_New_Failed;    //全新下载文件失败
    }

    /**
     * 连接到FTP服务器
     *
     * @param hostname 主机名
     * @param port     端口
     * @param username 用户名
     * @param password 密码
     * @return 是否连接成功
     * @throws IOException
     */
    public boolean connect(FTPClient ftpClient, String hostname, int port, String username, String password) throws IOException {
        ftpClient.connect(hostname, port);
        ftpClient.setControlEncoding("GBK");
        if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
            if (ftpClient.login(username, password)) {
                return true;
            }
        }
        disconnect(ftpClient);
        return false;
    }

    /**
     * 断开与远程服务器的连接
     *
     * @throws IOException
     */
    public void disconnect(FTPClient ftpClient) throws IOException {
        if (ftpClient.isConnected()) {
            ftpClient.disconnect();
        }
    }

    /**
     * 测试ftp
     *
     * @param hostname
     * @param port
     * @param username
     * @param password
     * @param fullPath
     * @return true 测试通过
     * @throws IOException
     */
    public boolean testConnect(String hostname, int port, String username, String password, String fullPath) throws IOException {
        FTPClient ftpClient = new FTPClient();
        boolean flag = connect(ftpClient, hostname, port, username, password);
        if (flag) {
            flag = false;
            //多级目录
            String path = fullPath.replace("/", File.separator)
                    .replace("\\", File.separator)
                    .replace("\\\\", File.separator);
            //假如远程目录不存在，则递回创建远程服务器目录
            int start = 0;
            int end = 0;
            if (path.startsWith(File.separator)) {
                start = 1;
            } else {
                start = 0;
            }
            end = path.indexOf(File.separator, start);
            if (end == -1) {
                end = path.length();
            }
            while (true) {
                String subDirectory = new String(path.substring(start, end).getBytes("GBK"), "iso-8859-1");
                if (!ftpClient.changeWorkingDirectory(subDirectory)) {
                    flag = false;
                    break;
                }
                start = end + 1;
                end = path.indexOf(File.separator, start);
                //检查所有目录是否创建完毕
                if (end <= start) {
                    flag = true;
                    break;
                }
            }
        }
        disconnect(ftpClient);
        return flag;
    }

    /**
     * 从FTP服务器上下载文件,支持断点续传，上传百分比汇报
     *
     * @param ftpClient
     * @param remote    远程文件路径
     * @param local     本地文件路径
     * @return
     * @throws IOException
     */
    public DownloadStatus download(FTPClient ftpClient, String remote, String local) throws IOException {
/*        if(!connect(ftpClient, hostname, port, username, password)){
            return DownloadStatus.Download_New_Failed;
        }*/
        //设置被动模式
        ftpClient.enterLocalPassiveMode();
        //设置以二进制方式传输
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        DownloadStatus result;
        //检查远程文件是否存在
        FTPFile[] files = ftpClient.listFiles(new String(remote.getBytes("GBK"), "iso-8859-1"));
        if (files.length != 1) {
            //System.out.println("远程文件不存在");
            return DownloadStatus.Remote_File_Noexist;
        }
        long lRemoteSize = files[0].getSize();
        File f = new File(local);
        //本地存在文件，进行断点下载
        if (f.exists()) {
            long localSize = f.length();
            //判定本地文件大小是否大于远程文件大小
            if (localSize >= lRemoteSize) {
                return DownloadStatus.Local_Bigger_Remote;
            }
            //进行断点续传，并记录状态
            FileOutputStream out = new FileOutputStream(f, true);
            ftpClient.setRestartOffset(localSize);
            InputStream in = ftpClient.retrieveFileStream(new String(remote.getBytes("GBK"), "iso-8859-1"));
            byte[] bytes = new byte[1024];
            long step = lRemoteSize / 100;
            long process = localSize / step;
            int c;
            while ((c = in.read(bytes)) != -1) {
                out.write(bytes, 0, c);
                localSize += c;
                long nowProcess = localSize / step;
                if (nowProcess > process) {
                    process = nowProcess;
                    //if (process % 10 == 0)
                    //System.out.println("下载进度：" + process);
                    //TODO 更新文件下载进度,值存放在process变量中
                }
            }
            in.close();
            out.close();
            boolean isDo = ftpClient.completePendingCommand();
            if (isDo) {
                result = DownloadStatus.Download_From_Break_Success;
            } else {
                result = DownloadStatus.Download_From_Break_Failed;
            }
        } else {
            OutputStream out = new FileOutputStream(f);
            InputStream in = ftpClient.retrieveFileStream(new String(remote.getBytes("GBK"), "iso-8859-1"));

            byte[] bytes = new byte[1024];
            long step = lRemoteSize / 100;
            long process = 0;
            long localSize = 0L;
            int c;
            while ((c = in.read(bytes)) != -1) {
                out.write(bytes, 0, c);
                localSize += c;
                long nowProcess;
                if (step < 1) {
                    step = 1;
                }
                nowProcess = localSize / step;
                if (nowProcess > process) {
                    process = nowProcess;
                    /*if (process % 10 == 0)
                        System.out.println("下载进度：" + process);*/
                    //TODO 更新文件下载进度,值存放在process变量中
                }
            }
            in.close();
            out.close();
            boolean upNewStatus = ftpClient.completePendingCommand();
            if (upNewStatus) {
                result = DownloadStatus.Download_New_Success;
            } else {
                result = DownloadStatus.Download_New_Failed;
            }
        }
        //disconnect(ftpClient);
        return result;
    }

    public byte[] download(FTPClient ftpClient, String remote) throws IOException {

        //设置被动模式
        ftpClient.enterLocalPassiveMode();
        //设置以二进制方式传输
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);

        //检查远程文件是否存在
        FTPFile[] files = ftpClient.listFiles(new String(remote.getBytes("GBK"), "iso-8859-1"));
        if (files.length != 1) {
            //System.out.println("远程文件不存在");
            return null;
        }

        InputStream in = ftpClient.retrieveFileStream(new String(remote.getBytes("GBK"), "iso-8859-1"));

        byte[] bytes = toByteArray(in);

        in.close();
        boolean upNewStatus = ftpClient.completePendingCommand();

        if (!upNewStatus) {
            return null;
        }
        return bytes;
    }

    public byte[] toByteArray(InputStream in) throws IOException {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int n = 0;
        while ((n = in.read(buffer)) != -1) {
            out.write(buffer, 0, n);
        }
        out.close();
        return out.toByteArray();
    }


    /**
     * 上传文件到FTP服务器，支持断点续传
     *
     * @param local  本地文件名称，尽对路径
     * @param remote 远程文件路径，支持多级目录嵌套，支持递回创建不存在的目录结构
     * @return 上传结果
     * @throws IOException
     */
    public UploadStatus upload(FTPClient ftpClient, String local, String remote) throws IOException {
        //设置PassiveMode传输
        ftpClient.enterLocalPassiveMode();
        //设置以二进制流的方式传输
        ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
        ftpClient.setControlEncoding("GBK");
        UploadStatus result;
        //对远程目录的处理
        String remoteFileName = remote;
        if (remote.contains("/")) {
            remoteFileName = remote.substring(remote.lastIndexOf("/") + 1);
            //创建服务器远程目录结构，创建失败直接返回
            if (createDirectory(remote, ftpClient) == UploadStatus.Create_Directory_Fail) {
                return UploadStatus.Create_Directory_Fail;
            }
        }
        //检查远程是否存在文件
        FTPFile[] files = ftpClient.listFiles(new String(remoteFileName.getBytes("GBK"), "iso-8859-1"));
        if (files.length == 1) {
            long remoteSize = files[0].getSize();
            File f = new File(local);
            long localSize = f.length();
            if (remoteSize == localSize) {
                return UploadStatus.File_Exits;
            } else if (remoteSize > localSize) {
                return UploadStatus.Remote_Bigger_Local;
            }
            //尝试移动文件内读取指针,实现断点续传
            result = uploadFile(remoteFileName, f, ftpClient, remoteSize);
            //假如断点续传没有成功，则删除服务器上文件，重新上传
            if (result == UploadStatus.Upload_From_Break_Failed) {
                if (!ftpClient.deleteFile(remoteFileName)) {
                    return UploadStatus.Delete_Remote_Faild;
                }
                result = uploadFile(remoteFileName, f, ftpClient, 0);
            }
        } else {
            result = uploadFile(remoteFileName, new File(local), ftpClient, 0);
        }
        //disconnect(ftpClient);
        return result;
    }

    /**
     * 递回创建远程服务器目录
     *
     * @param remotePath 远程服务器文件尽对路径
     * @param ftpClient  FTPClient 对象
     * @return 目录创建是否成功
     * @throws IOException
     */
    public UploadStatus createDirectory(String remotePath, FTPClient ftpClient) throws IOException {
        UploadStatus status = UploadStatus.Create_Directory_Success;
        String remote = remotePath.replace("/", File.separator).replace("\\", File.separator).replace("\\\\", File.separator);
        String directory = remote.substring(0, remote.lastIndexOf(File.separator) + 1);
        if (!directory.equalsIgnoreCase(File.separator)
                && !ftpClient.changeWorkingDirectory(new String(directory.getBytes("GBK"), "iso-8859-1"))) {
            //假如远程目录不存在，则递回创建远程服务器目录
            int start = 0;
            int end = 0;
            if (directory.startsWith(File.separator)) {
                start = 1;
            } else {
                start = 0;
            }
            end = directory.indexOf(File.separator, start);
            while (true) {
                String subDirectory = new String(remote.substring(start, end).getBytes("GBK"), "iso-8859-1");
                if (!ftpClient.changeWorkingDirectory(subDirectory)) {
                    if (ftpClient.makeDirectory(subDirectory)) {
                        ftpClient.changeWorkingDirectory(subDirectory);
                    } else {
                        //System.out.println("创建目录失败");
                        return UploadStatus.Create_Directory_Fail;
                    }
                }
                start = end + 1;
                end = directory.indexOf(File.separator, start);
                //检查所有目录是否创建完毕
                if (end <= start) {
                    break;
                }
            }
        }
        return status;
    }

    /**
     * 进入当前路径最后一级路径
     *
     * @param remotePath
     * @param ftpClient
     * @return
     * @throws IOException
     */
    public UploadStatus createLastDirectory(String remotePath, FTPClient ftpClient) throws IOException {
        UploadStatus status = UploadStatus.Create_Directory_Success;
        String remote = remotePath.replace("/", File.separator).replace("\\", File.separator).replace("\\\\", File.separator);
        int end = remote.lastIndexOf(File.separator);
        String tmp = remote.substring(0, end);
        int start = tmp.lastIndexOf(File.separator);
        String curDir = new String(tmp.substring(start + 1, end).getBytes("GBK"), "iso-8859-1");
        if (!ftpClient.changeWorkingDirectory(curDir)) {
            if (!ftpClient.makeDirectory(curDir)) {
                return UploadStatus.Create_Directory_Fail;
            }
            ftpClient.changeWorkingDirectory(curDir);
        }
        return status;
    }

    /**
     * 上传文件到服务器,新上传和断点续传
     *
     * @param remoteFile 远程文件名，在上传之前已经将服务器工作目录做了改变
     * @param localFile  本地文件 File句柄，尽对路径
     * @param ftpClient  FTPClient 引用
     * @return
     * @throws IOException
     */
    public UploadStatus uploadFile(String remoteFile, File localFile, FTPClient ftpClient, long remoteSize) throws IOException {
        UploadStatus status;
        //显示进度的上传
        long step = localFile.length() / 100 > 0 ? localFile.length() / 100 : 1;
        long process = 0;
        long localReadBytes = 0L;
        RandomAccessFile raf = new RandomAccessFile(localFile, "r");
        OutputStream out = ftpClient.appendFileStream(new String(remoteFile.getBytes("GBK"), "iso-8859-1"));
        //断点续传
        if (remoteSize > 0) {
            ftpClient.setRestartOffset(remoteSize);
            process = remoteSize / step;
            raf.seek(remoteSize);
            localReadBytes = remoteSize;
        }
        byte[] bytes = new byte[1024];
        int c;
        while ((c = raf.read(bytes)) != -1) {
            out.write(bytes, 0, c);
            localReadBytes += c;
            if (localReadBytes / step != process) {
                process = localReadBytes / step;
                //System.out.println("上传进度:" + process);
                //TODO 汇报上传状态
            }
        }
        out.flush();
        raf.close();
        out.close();
        boolean result = ftpClient.completePendingCommand();
        if (remoteSize > 0) {
            status = result ? UploadStatus.Upload_From_Break_Success : UploadStatus.Upload_From_Break_Failed;
        } else {
            status = result ? UploadStatus.Upload_New_File_Success : UploadStatus.Upload_New_File_Failed;
        }
        return status;
    }

    public void createFilePath(String path) throws InterruptedException {
        File filepath = new File(path);
        String realPath = filepath.getAbsolutePath();
        //System.out.println(realPath);
        String[] paths = realPath.split("\\\\");
        StringBuffer fullPath = new StringBuffer();
        for (int i = 0; i < paths.length; i++) {
            fullPath.append(paths[i]).append("\\\\");
            File file = new File(fullPath.toString());
            if (paths.length - 1 != i) {//判断path到文件名时，无须继续创建文件夹！
                if (!file.isDirectory() || !file.exists()) {
                    file.mkdir();
                    //System.out.println("创建目录为：" + fullPath.toString());
                    Thread.sleep(1500);
                }
            }
        }
    }

    /**
     * 转换文件的大小
     *
     * @param size
     * @return
     */
    public String format(long size) {
        if (size < 1024) {
            return size + "B";
        } else if (size < 1048576) {
            double beforeNum = size / 1024;
            double temp = size % 1024;
            double afterNum = temp / 1024;
            // 取小数点后1位
            double num = new BigDecimal(beforeNum + afterNum).setScale(1,
                    BigDecimal.ROUND_HALF_UP).doubleValue();
            return num + "KB";
        } else if (size < 1073741824) {
            double beforeNum = size / 1048576;
            double temp = size % 1048576;
            double afterNum = temp / 1048576;
            double num = new BigDecimal(beforeNum + afterNum).setScale(2,
                    BigDecimal.ROUND_HALF_UP).doubleValue();
            return num + "MB";
        } else {
            double beforeNum = size / 1073741824;
            double temp = size % 1073741824;
            double afterNum = temp / 1073741824;
            double num = new BigDecimal(beforeNum + afterNum).setScale(2,
                    BigDecimal.ROUND_HALF_UP).doubleValue();
            return num + "GB";
        }
    }


    /**
     * 进入多级目录
     *
     * @param sysFtpClient
     * @param path
     * @return
     * @throws IOException return true：进入成功
     */
    public boolean enterDir(FTPClient sysFtpClient, String path) throws IOException {
        boolean enter = true;
        int start = 0;
        int end = 0;
        if (path.startsWith(File.separator)) {
            start = 1;
        } else {
            start = 0;
        }
        end = path.indexOf(File.separator, start);
        if (end == -1) {
            end = path.length();
        }
        while (true) {
            String subDirectory = new String(path.substring(start, end).getBytes("GBK"), "iso-8859-1");
            if (!sysFtpClient.changeWorkingDirectory(subDirectory)) {
                enter = false;
                break;
            }
            start = end + 1;
            end = path.indexOf(File.separator, start);
            //检查所有目录是否创建完毕
            if (end <= start) {
                break;
            }
        }
        return enter;
    }

    /**
     * 转换系统路径格式
     *
     * @param srcPath
     * @return
     * @throws IOException
     */
    public String convertDirPath(String srcPath) throws IOException {
        return srcPath.replace("/", File.separator).replace("\\", File.separator).replace("\\\\", File.separator).replace("\\/", File.separator);
    }

    public static void main(String[] a) {

        FtpUtil instance = FtpUtil.getInstance();
        try {
            FTPClient ftpClient = new FTPClient();
            System.out.println(instance.connect(ftpClient,"192.168.2.180", 2121, "yjhh", "a1b2c3d4!"));
            System.out.println( instance.download(ftpClient,"0000B69B-4417-47B2-820B-8D95795F45F4/2a5656baa9444dc5b472f67282ef3ec4.jpg"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
